package ch01.test.test4;


import org.apache.log4j.Logger;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Map;

public class SimpleBeanConvertor {
    private static Logger logger = Logger.getLogger(SimpleBeanConvertor.class);

    /**
     * 将http请求中的参数赋值给指定类型JavaBean的相关属性
     * @param request   Http请求
     * @param targetType    目标JavaBean类型
     * @return    targetType 类型的实例
     * @param <T>
     */
    public static<T> T convert(HttpServletRequest request , Class<T> targetType) throws InstantiationException, IllegalAccessException, InvocationTargetException, ParseException, UnsupportedTypeException {
        //获取所有请求参数
        Map<String, String[]> params = request.getParameterMap();
        if (params.size() == 0) return null;

        //创建JavaBean实例
        T target = targetType.newInstance();

        Method [] allMethods = targetType.getMethods();
        if (allMethods != null && allMethods.length > 0){
            for (Method method:allMethods
                 ) {
                //仅仅处理前缀是set的方法
                if (method.getName().startsWith("set")){
                    Class[] args = method.getParameterTypes();      //获取参数列表
                    //仅仅处理单参
                    if (args.length == 1){
                        //获取set方法对应的请求参数：setName -> name
                        String paramName = method.getName().substring(3,4).toLowerCase() + method.getName().substring(4);
                        //请求中有此参数
                        if (params.containsKey(paramName)){
                            try{
                                //将请求参数值转换为setter方法参数类型
                                Object value = parseValue(params.get(paramName),args[0]);
                                method.invoke(target,value);
                            }catch (ParseException | UnsupportedTypeException e){
                                logger.debug("参数转换错误",e);
                                e.printStackTrace();
                                throw e;
                            }
                        }else if (Boolean.class == args[0] || boolean.class == args[0]){
                            //如果是boolean，不存在表示false
                            method.invoke(target,false);
                        }
                    }
                }
            }
        }
        return target;
    }

    /**
     * 将http请求中的String类型的参数值转换为相关属性的类型
     * 支持String，yyyy-MM-dd 格式的日期，基本类型以及包装类，BigDecimal,BigInteger
     * 修改此方法可以添加对更多类型的支持
     * @param value          Http请求参数值
     * @param type           属性类型
     * @return               转换后的参数
     * @throws ParseException
     */
    private static Object parseValue(String [] value , Class type) throws ParseException, UnsupportedTypeException {
        if (String.class == type){
            return value[0];
        }
        if (java.util.Date.class == type){
            return new SimpleDateFormat("yyyy-MM-dd").parse(value[0]);
        }
        if (boolean.class == type || Boolean.class == type){
            if (type.equals("false")){
                return false;
            }else{
                return true;
            }
        }
        if (char.class == type || Character.class == type){
            return value[0].charAt(0);
        }
        if (int.class == type || Integer.class == type){
            return Integer.valueOf(value[0]);
        }
        if (short.class == type || byte.class == type || long.class == type || float.class == type || double.class == type){
            try{
                //将值类型变更为对应的包装类型
                type = Class.forName("java.lang."+type.getName().substring(0,1).toUpperCase()+type.getName().substring(1));

            }catch (ClassNotFoundException e){
                e.printStackTrace();
            }
            if (type.getName().startsWith("java.lang.") || type.getName().startsWith("java.math.")){
                try{
                    return type.getConstructor(String.class).newInstance(value[0]);
                }catch (Exception e){
                    e.printStackTrace();
                }
                throw new UnsupportedTypeException();
            }
        }
        return null;
    }
}
